#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <cassert>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <thread>
#include <mutex>
#include <memory>
#include <condition_variable>
#include <typeinfo>
#include <functional>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

// 日志打印
// 如果没有不定参，就+上##
// strftime:将ltm中的变量某种格式放在tmp中
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL INF
#define LOG(level, format, ...)                                                                                         \
    do                                                                                                                  \
    {                                                                                                                   \
        if (level < LOG_LEVEL)                                                                                          \
            break;                                                                                                      \
        const time_t t = time(nullptr);                                                                                 \
        struct tm *ltm = localtime(&t);                                                                                 \
        char temp[32] = {0};                                                                                            \
        strftime(temp, 31, "%H:%M:%S", ltm);                                                                            \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void *)pthread_self(), temp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

#define LOG_INF(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define LOG_DBG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define LOG_ERR(format, ...) LOG(ERR, format, ##__VA_ARGS__)

#define BUFFER_DEFAULT_SIZE 1024

class Buffer
{
private:
    std::vector<char> _buffer;
    uint64_t read_idx;  // 读偏移
    uint64_t write_idx; // 写偏移

public:
    Buffer() : read_idx(0), write_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    ~Buffer() {}
    char *Begin() { return &(*_buffer.begin()); }
    // 获取当前写入位置地址
    char *WritePostion() { return Begin() + write_idx; }

    // 获取当前读取起始地址
    char *ReadPostion() { return Begin() + read_idx; }

    // 获取缓冲区末尾空闲空间的大小 -->缓冲区大小-写偏移
    uint64_t TailFreeSpaceSize()
    {
        return _buffer.size() - write_idx;
    }

    // 获取缓冲区起始空闲空间的大小-->读的偏移量
    uint64_t HeadFreeSpaceSize()
    {
        return read_idx;
    }

    // 获取可读数据的大小-->写偏移-读偏移
    uint64_t ReadableDataSize()
    {
        return write_idx - read_idx;
    }

    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后偏移的大小，不能查过可读数据大小
        assert(len <= ReadableDataSize());
        read_idx += len;
    }

    // 将写偏移向后移动
    void MoveWriteoffset(uint64_t len)
    {
        assert(len <= TailFreeSpaceSize() + HeadFreeSpaceSize());
        write_idx += len;
    }
    // 确保可写空间足够
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果缓冲区末尾空间空间足够
        if (len <= TailFreeSpaceSize())
        {
            return;
        }
        // 如果末尾不够，加上头空闲空间足够，就要挪动数据
        else if (len <= TailFreeSpaceSize() + HeadFreeSpaceSize())
        {
            // 保存数据大小
            uint64_t datasize = ReadableDataSize();
            // 挪动数据到最前面
            std::copy(ReadPostion(), ReadPostion() + datasize, Begin());
            read_idx = 0;
            write_idx = datasize;
        }
        // 空间不够，扩容，不挪动数据
        else
        {
            _buffer.resize(write_idx + len);
        }
    }

    // 写入数据
    void WriteData(const void *data, uint64_t len)
    {
        // 保证有足够空间,能够将数据拷贝进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePostion());
    }
    // 将数据push进去，也就是将写位置更新，将写位置往后移动
    void WriteAndPush(const void *data, uint64_t len)
    {
        WriteData(data, len);
        MoveWriteoffset(len);
    }
    // 写入string数据
    void WriteStringData(const std::string &data)
    {
        return WriteData(data.c_str(), data.size());
    }
    void WriteStringDataAndPush(const std::string &data)
    {
        WriteStringData(data);
        MoveWriteoffset(data.size());
    }
    // 写入buffer数据
    void WriteBufferData(Buffer &data)
    {
        return WriteData(data.ReadPostion(), data.ReadableDataSize());
    }
    void WriteBufferDataAndPush(Buffer &data)
    {
        WriteBufferData(data);
        MoveWriteoffset(data.ReadableDataSize());
    }

    // 读取数据->将读取到的数据保存在buf中
    void ReadData(void *buf, uint64_t len)
    {
        // 保证读取数据不能超过可读数据长度
        assert(len <= ReadableDataSize());
        std::copy(ReadPostion(), ReadPostion() + len, (char *)buf);
    }
    // 读取数据后，将读偏移更新
    void ReadDataAndPop(void *buf, uint64_t len)
    {
        ReadData(buf, len);
        MoveReadOffset(len); // 读偏移向后移动
    }

    // 读取string数据
    std::string ReadStringData(uint64_t len)
    {
        // 要求读取的数据不能超过可读数据的大小
        assert(len <= ReadableDataSize());
        std::string str;
        str.resize(len);
        ReadData(&str[0], len);
        return str;
    }
    std::string ReadStringDataAndPop(uint64_t len)
    {
        assert(len <= ReadableDataSize());
        std::string str = ReadStringData(len);
        MoveReadOffset(len); // 将读偏移更新
        return str;
    }

    // 查找换行符
    char *FindCRLF()
    {
        void *res = memchr(ReadPostion(), '\n', ReadableDataSize());
        return (char *)res;
    }
    // 获取一行数据
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
        {
            return "";
        }
        return ReadStringData(pos - ReadPostion() + 1);
    }
    std::string GetLinePop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区->只需要将缓冲区的读写偏移归零
    void clear()
    {
        read_idx = 0;
        write_idx = 0;
    }
};

#define MAX_LISTEN 1024
class Socket
{
public:
    Socket() : sockfd_(-1) {}
    Socket(int fd) : sockfd_(fd) {}
    ~Socket() { Close(); }
    int Fd() { return sockfd_; }
    // 1、创建套接字
    int Create()
    {
        sockfd_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sockfd_ < 0)
        {
            LOG_ERR("Create sockfd fail");
            return false;
        }
        // std::cout << "Create sockfd success, fd:" << sockfd_ << std::endl;
        return true;
    }
    // 2、绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = bind(sockfd_, (const struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            LOG_ERR("Bind Sockfd Fail");
            return false;
        }
        // std::cout << "Bind Sockfd success" << std::endl;
        return true;
    }
    // 3、监听套接字
    bool Listen(int backlog = MAX_LISTEN) //?s
    {
        int ret = listen(sockfd_, backlog);
        if (ret < 0)
        {
            LOG_ERR("Sock Listen Fail");
            return false;
        }
        // std::cout << "Sock Listen success" << std::endl;
        return true;
    }
    // 4、向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = connect(sockfd_, (const struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            LOG_ERR("Connect server Fail");
            return false;
        }
        return true;
    }
    // 5、获取新连接
    int Accept()
    {
        int newfd = accept(sockfd_, NULL, NULL);
        if (newfd < 0)
        {
            LOG_ERR("Socket Accept Fail");
            return -1;
        }
        // std::cout << "获取到一个新连接, fd:" << newfd << std::endl;
        return newfd;
    }
    // 6、接受数据
    ssize_t Recv(void *buffer, int len, int flag = 0)
    {
        ssize_t ret = recv(sockfd_, buffer, len, flag);
        if (ret <= 0)
        {
            // EAGAIN：表示sock的接受缓冲区中没有数据了，在非阻塞情况下会出现这种情况
            // EINTR：表示当前socket阻塞等待，被信号打断了
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示接受数据为0
            }
            LOG_ERR("Socket Recv Fail");
            return -1;
        }
        // std::cout << "接受数据成功" << std::endl;
        return ret;
    }
    ssize_t NonBlockRevc(void *buffer, size_t len)
    {
        return Recv(buffer, len, MSG_DONTWAIT); // MSG_DOONTWAIT:表示当前为非阻塞
    }
    // 7、发送数据
    ssize_t Send(const void *buffer, int len, int flag = 0)
    {
        ssize_t ret = send(sockfd_, buffer, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            LOG_ERR("Socket Send Fail");
            return -1;
        }
        // std::cout << "send date success" << std::endl;
        return ret;
    }
    ssize_t NonBlockSend(char *buffer, size_t len)
    {
        if (len == 0)
            return 0;
        return Send(buffer, len, MSG_DONTWAIT); // MSG_DOONTWAIT:表示当前为非阻塞
    }
    // 8、关闭套接字
    void Close()
    {
        if (sockfd_ != -1)
        {
            close(sockfd_);
            sockfd_ = -1;
        }
    }
    // 9、创建客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        // std::cout << "创建客户端成功" << std::endl;
        return true;
    }
    // 10、创建服务器连接
    bool CreateServer(uint16_t port, const std::string ip = "0.0.0.0", bool block_flag = false)
    {
        if (Create() == false)
            return false;
        if (block_flag)
            SetNonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ReuseAddress();
        return true;
    }
    // 11、设置套接字选项-开启地址端口重用
    void ReuseAddress()
    {
        int val = 1;
        setsockopt(sockfd_, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(val));
        val = 1;
        setsockopt(sockfd_, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(val));
    }
    // 12、设置套接字阻塞属性-设置为非阻塞
    void SetNonBlock()
    {
        int flag = fcntl(sockfd_, F_GETFL, 0);
        fcntl(sockfd_, F_SETFL, flag | O_NONBLOCK);
    }

private:
    int sockfd_;
};

class Poller; // 声明一个Poller类,只是声明，无法访问类里面的成员
class EventLoop;
class Channel
{
private:
    int _fd;
    // Poller *_poller;
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数
public:
    Channel(int fd, EventLoop *loop) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    uint32_t GetEvents() { return _events; }                // 获取想要监控的事件
    void SetREvents(uint32_t events) { _revents = events; } // 设置实际就绪的事件
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update(); // 添加到EventLoop事件监控中去
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控
    void Remove(); // 后边会调用EventLoop接口移除监控
    // 更新事件监控
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        // EPOLLRDHUP：对方关闭了连接 EPOLLPRI：优先数据
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            if (_read_callback)
            {
                _read_callback();
            }
        }
        /*有可能会释放连接的操作事件，一次只处理一个*/
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
                _error_callback(); // 一旦出错，就会释放链接，没必要调用任意回调了，因此要放到前面进行任意回调
        }
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
                _close_callback();
        }
        /*不管任何事件，都调用的回调函数*/ // 放到事件完毕之后调用，刷新活跃度
        if (_event_callback)
            _event_callback();
    }
};
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private:
    // 实际对epoll的直接操作
    void Updata(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->GetEvents();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            LOG_ERR("Epoll_ctl Fail");
            // abort();// 退出程序
        }
        // std::cout << "添加读事件监控成功" << std::endl;
        return;
    }
    // 判断一个channel是否已经添加了事件监控。
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            // 没有找到
            return false;
        }
        return true;
    }

public:
    // 进行epoll的创建
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            LOG_ERR("Epoll_create Fail!!!");
            abort(); // 退出程序
        }
    }
    // 添加或修改监控
    void UpdataEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在就添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Updata(channel, EPOLL_CTL_ADD);
        }
        // 存在就更新
        return Updata(channel, EPOLL_CTL_MOD);
    }
    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            _channels.erase(it);
        }
        Updata(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃链接
    void Poll(std::vector<Channel *> *active) // 开始监控，就绪事件获取上来
    {
        // int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1); // 设置为-1:阻塞等待
        if (nfds < 0)
        {
            // EINTR:调用被信号中断
            if (errno == EINTR)
            {
                LOG_ERR("Epoll_wait Fail:%s", strerror(errno));
                abort(); // 退出程序
            }
        }

        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际的就绪事件
            active->push_back(it->second);
        }
        // std::cout << "监控成功,返回活跃链接" << std::endl;
        return;
    }
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;         // 定时器任务对象ID
    uint32_t _timeout;    // 定时任务的超时时间
    bool _canceled;       // false-表示没有被取消， true-表示被取消
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb) : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _release();
    }
    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }
};

class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;     // 当前的秒针，走到哪里释放哪里，释放哪里，就相当于执行哪里的任务
    int _capacity; // 表盘最大数量---其实就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop *_loop;
    int _timerfd; // 定时器描述符--可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }
    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            LOG_ERR("TIMERFD CREATE FAILED!");
            abort();
        }
        // int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为1s后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后，每次超时的间隔时
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            LOG_ERR("READ TIMEFD FAILED!");
            abort();
        }
        return times;
    }
    // 这个函数应该每秒钟被执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }
    void OnTime()
    {
        // 根据实际超时的次数，执行对应的超时任务
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }
    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找着定时任务，没法刷新，没法延迟
        }
        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找着定时任务，没法刷新，没法延迟
        }
        PtrTask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(60), _tick(0), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerfd()), _timer_channel(new Channel(_timerfd, _loop))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件监控
    }
    /*定时器中有个_timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题*/
    /*如果不想加锁，那就把对定期的所有操作，都放到一个线程中进行*/
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    // 刷新/延迟定时任务
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);
    /*这个接口存在线程安全问题--这个接口实际上不能被外界使用者调用，只能在模块内，在对应的EventLoop线程内执行*/
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
};

class EventLoop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _thread_id; // 线程id
    int _event_fd;              // eventfd唤醒IO事件监控可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller;              // 对描述符事件的监控
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 实现任务池线程操作的安全
    TimerWheel _timer_wheel;     // 定时器模块
public:
    // 运行任务池中所有的任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for (auto &f : functor)
        {
            f();
        }
        return;
    }
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            LOG_ERR("Create Eventfd fail");
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void ReadEventFd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR:被信号打断，EAGAIN:无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LOG_ERR("Read Eventfd fail");
            abort();
        }
        return;
    }
    void WakeUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG_ERR("WakeUpEventFd fail");
            abort();
        }
        return;
    }

public:
    EventLoop()
        : _thread_id(std::this_thread::get_id()),
          _event_fd(CreateEventFd()),
          _event_channel(new Channel(_event_fd, this)),
          _timer_wheel(this)
    {
        // 给eventfd设置可读事件回调，读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));
        // 启动可读事件监控
        _event_channel->EnableRead();
    }
    // 三步走-》 事件监控-》就绪事件处理-》执行任务
    void Start()
    {
        while (1)
        {
            // 事件监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            // 就绪事件处理
            for (auto &channel : actives)
            {
                channel->HandleEvent();
            }
            // 执行任务池任务
            RunAllTask();
        }
    }
    // 判断当前线程是否是EventLoop对应的线程
    bool IsInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }
    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }
    // 判断当前执行的任务是否处于当前线程，如果是就执行，不是则压入任务池
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
            return cb();
        return QueueInLoop(cb);
    }
    // 将任务压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致epoll阻塞
        // 其实是给eventfd写入一个数据，eventfd就会触发可读事件
    }
    // 添加/修改描述符事件监控
    void UpdataEvent(Channel *channel)
    {
        return _poller.UpdataEvent(channel);
    }
    // 移除描述符事件监控
    void RemoveEvent(Channel *channel)
    {
        return _poller.RemoveEvent(channel);
    }
    // 添加定时任务
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        return _timer_wheel.TimerAdd(id, delay, cb);
    }
    // 刷新定时任务
    void TimerRefresh(uint64_t id)
    {
        return _timer_wheel.TimerRefresh(id);
    }
    // 取消定时任务
    void TimerCancel(uint64_t id)
    {
        return _timer_wheel.TimerCancel(id);
    }
    // 是否存在定时器任务
    bool HasTimer(uint64_t id)
    {
        return _timer_wheel.HasTimer(id);
    }
};

class LoopThread
{
private:
    // 用于实现_loop获取的同步关系，避免了线程创建了，但是_loop变量还没有实例之前就去获取_loop
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLoop指针变量 这个变量需要在线程内实例化
    std::thread _thread;           // EventLoop对应的线程
private:
    // 实例化EventLoop对象，并唤醒_cond上有可能阻塞的线程，并开始运行EventLoop模块的功能
    void ThreadEntry()
    {
        EventLoop loop; // 实例化EventLoop对象
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    // 返回当前线程关联的EventLoop对象指针
    EventLoop *GetLoop()
    {
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; }); // 条件变量：loop为空就一直等待
            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool
{
private:
    int _thread_count; // 从属线程的数量
    int _nextloop_idx;
    EventLoop *_baseloop;               // 主eventloop,运行在主线程，从属线程数量为0,则所有操作都在baseloop中进行
    std::vector<LoopThread *> _threads; // 保存所有的loopthread对象
    std::vector<EventLoop *> _loops;    // 从属线程数量大于0则从loops中进行线程eventloop
public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _nextloop_idx(0), _baseloop(baseloop) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void Create() // 创建所有的从属线程
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
        return;
    }
    // 获取从属线程对应关联的EventLoop对象
    EventLoop *NextLoop()
    {
        // 如果从属线程数量为0.则直接分配给baseloop线程·处理
        if (_thread_count == 0)
        {
            return _baseloop;
        }
        _nextloop_idx = (_nextloop_idx + 1) % _thread_count;
        return _loops[_nextloop_idx];
    }
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info &type() { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() { return new placeholder(_val); }

    public:
        T _val;
    };
    holder *_content;

public:
    Any() : _content(NULL) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : NULL) {}
    ~Any() { delete _content; }

    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }
    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

class Connection;
// DISCONNECTED:连接关闭状态
// CONNECTING：连接建立成功--待处理状态
// CONNECTED：连接建立成功---各种设置已完成，可以通信的状态
// DISCONNECTING：待关闭连接的状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatus;

using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一id， 便于连接的管理和操作
    // uint64_t _timer_id; //定时器id，必须是唯一的，这块是为了简化操作使用_conn_id作为定时器id
    int _sockfd;                   // 连接关联的描述符id
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认是false
    EventLoop *_loop;              // 连接所关联的一个EventLoop
    ConnStatus _statu;             // 连接的状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接事件管理
    Buffer _in_buffer;             // 输入缓冲区管理
    Buffer _out_buffer;            // 输出缓冲区管理
    Any _context;                  // 请求的接受处理上下文

    // using PtrConnection = std::shared_ptr<Connection>;
    using ConnectionCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using CloseCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    // 这个四个回调函数，是服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）
    ConnectionCallback _connection_callback; //
    MessageCallback _message_callback;       //
    CloseCallback _close_callback;
    AnyEventCallback _anyevent_callback;
    // 组件内的连接关闭回调-- 组件内设置，因为服务器组件会把所有的连接管理起来
    // 一旦某个连接要关闭，就应该从管理的地方移除自己的信息
    CloseCallback _server_close_callback;

private:
    // 五个channel事件回调函数
    // 描述符可读事件触发后的回调函数，接受socket数据放到缓冲区中，调用MessageCallback回调函数
    void HandleRead()
    {
        // 1、接受socket数据放到缓冲区
        char buffer[65536];
        int ret = _socket.NonBlockRevc(buffer, 65535);
        if (ret < 0)
        {
            // 出错了不能直接关闭链接
            return ShutdownInLoop();
        }
        // 这里等于0表示是没有读取到数据，并不是连接断开了，连接断开为-1
        _in_buffer.WriteAndPush(buffer, ret);
        // 2、调用message_callback进行业务处理
        if (_in_buffer.ReadableDataSize() > 0)
        {
            // shared_from_this是从当前对象自身获取的shared_ptr管理的对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符可写事件触发后的回调函数，将发送缓冲区的数据进行发送
    void HandleWrite()
    {
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPostion(), _out_buffer.ReadableDataSize());
        if (ret < 0)
        {
            // 发送错误就关闭连接
            if (_in_buffer.ReadableDataSize() > 0) //?
            {
                _message_callback(shared_from_this(), &_in_buffer); //?
            }
            return Release(); // 直接关闭连接
        }
        _out_buffer.MoveReadOffset(ret); // 发送成功，将读偏移移动
        if (_out_buffer.ReadableDataSize() == 0)
        {
            // 没有数据进行发送，就关闭写事件
            _channel.DisableWrite();
            // 当前连接状态为待关闭状态，直接释放链接
            if (_statu == DISCONNECTING)
                return Release();
        }
        return;
    }
    // 描述符关闭事件触发后的回调函数
    void HandleClose()
    {
        // 一旦连接关闭了，套接字就什么也干不了，因此缓冲区有数据就处理，处理完就关闭链接
        if (_out_buffer.ReadableDataSize() > 0)
        {
            return _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符错误事件触发后的回调函数
    void HandleError()
    {
        return Release();
    }
    // 描述符任意事件触发后的回调函数---1、刷新连接的活跃度--延迟定时任务   2、调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_anyevent_callback)
        {
            _anyevent_callback(shared_from_this());
        }
    }
    // 获取连接之后，所处的状态下要进行各种设置（启动读监控、调用回调函数）
    void EstablishedInLoop()
    {
        // 1、修改连接状态
        assert(_statu == CONNECTING); // 当前状态为半连接状态
        _statu = CONNECTED;           // 当前函数执行完毕,则连接进入已完成状态
        // 2、启动读事件监控
        _channel.EnableRead();
        // 3、调用回调函数
        if (_connection_callback)
            _connection_callback(shared_from_this());
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1、修改连接状态，将其置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2、移除连接事件监控
        _channel.Remove();
        // 3、关闭描述符
        _socket.Close();
        // 4、如果当前定时器队列中还有销毁任务，就取消任务
        if (_loop->HasTimer(_conn_id))
            CancelIncativeReleaseInLoop();
        // 5、调用组件使用者关闭回调函数，如果先移除服务器的连接管理会出错
        if (_close_callback)
            _close_callback(shared_from_this());
        // 6、移除服务器内部的连接管理
        if (_server_close_callback)
            _server_close_callback(shared_from_this());
    }
    // 并不是实际的发送数据的接口，只是把数据放到发送缓冲区中，启动可写事件监控
    // buf不用使用引用，buf是一个构造的新的临时对象
    void SendInLoop(Buffer buf)
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferDataAndPush(buf);
        if (_channel.WriteAble() == false) // 是否监控了可写
        {
            _channel.EnableWrite(); // 启动可写事件监控
        }
    }
    // 这个接口并非实际的关闭连接的操作，需要判断缓冲区中是否有数据待处理，待发送
    void ShutdownInLoop()
    {
        _statu = DISCONNECTING; // 设置为半关闭状态
        if (_in_buffer.ReadableDataSize() > 0)
        {
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }
        if (_out_buffer.ReadableDataSize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        // 没有数据发送，直接关闭连接
        if (_out_buffer.ReadableDataSize() == 0)
        {
            Release();
        }
    }
    // 启动非活跃连接释放
    void EableInactiveReleaseInLoop(int sec)
    {
        // 1、将判断标志位 _enable_inactive_release标志为true
        _enable_inactive_release = true;
        // 2、如果要添加的定时任务已经存在，那就刷新延迟一下即可
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerRefresh(_conn_id);
        }
        // 3、不存在就添加
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    void CancelIncativeReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }
    // 协议切换
    void UpDealInLoop(const Any &context,
                      const ConnectionCallback &conn,
                      const MessageCallback &msg,
                      const CloseCallback &closed,
                      const AnyEventCallback &anyevent)
    {
        _context = context;
        _connection_callback = conn;
        _message_callback = msg;
        _close_callback = closed;
        _anyevent_callback = anyevent;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd),
                                                                _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(sockfd),
                                                                _channel(_sockfd, _loop)
    {
        // 设置回调函数
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
    }
    ~Connection()
    {
        LOG_DBG("Release Connection:%p", this);
    }
    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    int Id() { return _conn_id; }
    // 是否处于一个CONNECTED的状态
    bool connected() { return _statu == CONNECTED; }
    // 设置上下文---连接建立已完成时进行调用
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文
    Any *GetContext() { return &_context; }
    void SetConnectionCallback(const ConnectionCallback &cb) { _connection_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetCloseCallback(const CloseCallback &cb) { _close_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _anyevent_callback = cb; }
    void SetSrvClosedCallback(const CloseCallback &cb) { _server_close_callback = cb; }
    // 连接建立完成之后，进行channel回调设置，启动读监控，调用_connection_callback
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据，将数据放到发送缓冲区，启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data，可能是个临时空间，我们现在只是把发送操作压入到任务池中，有可能并没有立即执行
        // 因此有可能执行的时候，data指向的空间可能被释放了
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口---并不实际关闭，需要判断有没有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }
    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃连接销毁，定义多长时间无通信是非活跃，添加定时任务
    void EableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃连接销毁
    void CancelIncativeRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelIncativeReleaseInLoop, this));
    }
    // 切换协议--重置上下文以及阶段性处理函数 ---这个接口必须在EventLoop中立即执行
    // 防备新的事件触发后，处理的时候，切换协议任务还没有被执行，导致数据使用原来的协议进行处理
    void UpDeal(const Any &context, const ConnectionCallback &conn,
                const MessageCallback &msg, const CloseCallback &closed, const AnyEventCallback &anyevent)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpDealInLoop, this, context, conn, msg, closed, anyevent));
    }
};

class Acceptor
{
private:
    Socket _socket;   // 用户创建监听套接字
    EventLoop *_loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 用于对监听套接字进行事件管理---比如读事件之后该怎么处理
    using AcceptorCallBack = std::function<void(int)>;
    AcceptorCallBack _acceptor_callback;

private:
    // 监听套接字的读事件回调 ---获取新连接后，调用_acceptor_callback函数
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            return;
        }
        if (_acceptor_callback)
            _acceptor_callback(newfd);
    }
    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

public:
    // 不能将启动读事件放在构造函数中，必须放在设置回调函数之后，再去启动
    // 否则有可能造成启动监控后，有事件立即就绪，处理的时候，回调函数还没有被设置，新连接得不到处理，从而导致资源泄漏
    Acceptor(EventLoop *loop, int port) : _socket(CreateServer(port)), _loop(loop), _channel(_socket.Fd(), _loop)
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
        _channel.EnableRead();
    }
    void SetAcceptorCallBack(const AcceptorCallBack &cb) { _acceptor_callback = cb; }
    void Listen() { _channel.EnableRead(); }
};

class TcpServer
{
private:
    uint64_t _next_id; // 这是一个自动增长的连接ID，
    int _port;
    int _timeout;                                       // 这是非活跃连接的统计时间---多长时间无通信就是非活跃连接
    bool _enable_inactive_release;                      // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                // 这是主线程的EventLoop对象，负责监听事件的处理
    Acceptor _acceptor;                                 // 这是监听套接字的管理对象
    LoopThreadPool _pool;                               // 这是从属EventLoop线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理所有连接对应的shared_ptr对象

    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    using Functor = std::function<void()>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

private:
    void RunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
    // 为新连接构造一个Connection进行管理
    void NewConnection(int fd)
    {
        _next_id++;
        PtrConnection connection(new Connection(_pool.NextLoop(), _next_id, fd));
        connection->SetMessageCallback(_message_callback);
        connection->SetCloseCallback(_closed_callback);
        connection->SetConnectionCallback(_connected_callback);
        connection->SetAnyEventCallback(_event_callback);
        connection->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release)
            connection->EableInactiveRelease(_timeout); // 启动非活跃超时销毁
        connection->Established();                      // 就绪初始化---启动读事件监控
        _conns.insert(std::make_pair(_next_id, connection));
    }
    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
        {
            _conns.erase(it);
        }
    }
    // 从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

public:
    TcpServer(int port) : _port(port),
                          _next_id(0),
                          _enable_inactive_release(false),
                          _acceptor(&_baseloop, port),
                          _pool(&_baseloop)
    {
        _acceptor.SetAcceptorCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen(); // 将监听套接字挂到baseloop上开始事件监控
    }
    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start()
    {
        _pool.Create(); // 创建线程池中的从属线程
        _baseloop.Start();
    }
};

void Channel::Remove()
{
    return _loop->RemoveEvent(this);
}
void Channel::Update()
{
    return _loop->UpdataEvent(this);
}

// 因为很多的定时任务涉及到连接操作，需要考虑线程安全
// 定时器中有一个_timers的成员，定时器信息的操作有可能在多个线程中进行，因此需要考虑线程安全问题
// 如果不想加锁进行保护，就要把对定时器的操作，放在同一个线程中进行
// 添加定时任务
void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
// 刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
// 取消定时任务
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

class Network
{
public:
    Network()
    {
        LOG_DBG("SIGPIPE INIT");
        signal(SIGPIPE, SIG_IGN);
    }
};
static Network nw;
#endif

/*#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#endif  防止头文件重复包含*/